package com.zhugang.sort;

import java.util.Arrays;
import java.util.List;

import static java.util.stream.Collectors.toList;

/**
 * @program algorithms
 * @description: 排序算法
 * @author: chanzhugang
 * @create: 2022/02/24 22:40
 */
public class Sort {

    /**
     * 插入排序： 找到要插入因素的位置，如果大于该元素搬移数据
     *
     * @param a
     * @param n
     */
    public void insertSort(int[] a, int n) {
        for (int i = 0; i < n; i++) {
            int val = a[i];
            int j = i - 1;
            for (; j >= 0; j--) {
                if (a[j] > val) {
                    // 搬移数据
                    a[j + 1] = a[j];
                } else {
                    break;
                }
            }
            // 找到正确位置
            a[j + 1] = val;
        }
    }

    public void insertSort1(int[] a, int n) {
        for (int i = 0; i < n; i++) {
            int val = a[i];
            int j = i - 1;
            while (j >= 0 && a[j] > val) {
                a[j + 1] = a[j];
                j--;
            }
            a[j + 1] = val;
        }
    }


    /**
     * 选择排序：选择未排序中最小值放在已排序末尾（即外层循环索引，交换数据）
     *
     * @param a
     * @param n
     */
    public void selectSort(int[] a, int n) {
        for (int i = 0; i < n - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (a[j] < a[minIndex]) {
                    // 找最小值索引
                    minIndex = j;
                }
            }
            // 交换位置，放在已排序末尾
            int temp = a[i];
            a[i] = a[minIndex];
            a[minIndex] = temp;
        }

    }

    /**
     * 冒泡排序：比较相邻元素并交换位置
     *
     * @param a
     * @param n
     */
    public void bubbleSort(int[] a, int n) {
        for (int i = 0; i < n; i++) {
            boolean flag = false;
            for (int j = 0; j < n - i - 1; j++) {
                if (a[j] > a[j + 1]) {
                    // 比较元素并交换
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                    // 此次循环有交换
                    flag = true;
                }
            }
            // 无交换退出循环
            if (!flag) break;
        }
    }

    /**
     * 归并排序：找中间数，递归分成两个有序数组，再合并一个数组
     *
     * @param a
     * @param n
     */
    public void mergeSort(int[] a, int n) {
        mergeSort(a, 0, n);
    }

    private void mergeSort(int[] a, int l, int r) {
        if (r - l <= 1) {
            return;
        }
        int mid = (l + r) / 2;
        // 递归排序
        mergeSort(a, l, mid);
        mergeSort(a, mid, r);
        merge(a, l, mid, r);
    }

    private void merge(int[] a, int l, int mid, int r) {
        int[] left = Arrays.copyOfRange(a, l, mid + 1);
        int[] right = Arrays.copyOfRange(a, mid, r + 1);
        // 哨兵
        left[left.length - 1] = right[right.length - 1] = Integer.MAX_VALUE;
        int i = 0, j = 0;
        for (int k = l; k < r; k++) {
            // 合并成一个有序数组
            if (left[i] < right[j]) {
                a[k] = left[i++];
            } else {
                a[k] = right[j++];
            }
        }

    }

    /**
     * 快排：找一个数，小的放右边，大的放右边
     *
     * @param a
     * @return
     */
    public List<Integer> quickSort(List<Integer> a) {
        return quick(a);
    }

    private List<Integer> quick(List<Integer> a) {
        if (a.size() <= 1) {
            return a;
        }
        // 取第一个数
        int val = a.get(0);
        List<Integer> left = a.stream().filter(data -> data < val).collect(toList());
        List<Integer> mid = a.stream().filter(data -> data == val).collect(toList());
        List<Integer> right = a.stream().filter(data -> data > val).collect(toList());

        left = quick(left);
        right = quick(right);

        left.addAll(mid);
        left.addAll(right);
        return left;
    }

    // 桶排序

    public static void main(String[] args) {
        Sort sort = new Sort();
        int[] a = new int[]{3, 5, 7, 9, 2, 4, 6, 8};
        //   sort.insertSort(a, a.length);
        //   sort.selectSort(a, a.length);
        //   sort.bubbleSort(a, a.length);
        sort.mergeSort(a, a.length);


        System.out.println(Arrays.toString(a));

        List<Integer> res = sort.quickSort(Arrays.asList(3, 5, 7, 9, 2, 4, 6, 8));
        for (Integer re : res) {
            System.out.println(re);
        }
    }
}